home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / sre_compile.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  11KB  |  492 lines

  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import _sre
  5. import sys
  6. from sre_constants import *
  7. if _sre.CODESIZE == 2:
  8.     MAXCODE = 65535
  9. else:
  10.     MAXCODE = 0xFFFFFFFFL
  11.  
  12. def _identityfunction(x):
  13.     return x
  14.  
  15.  
  16. def set(seq):
  17.     s = { }
  18.     for elem in seq:
  19.         s[elem] = 1
  20.     
  21.     return s
  22.  
  23. _LITERAL_CODES = set([
  24.     LITERAL,
  25.     NOT_LITERAL])
  26. _REPEATING_CODES = set([
  27.     REPEAT,
  28.     MIN_REPEAT,
  29.     MAX_REPEAT])
  30. _SUCCESS_CODES = set([
  31.     SUCCESS,
  32.     FAILURE])
  33. _ASSERT_CODES = set([
  34.     ASSERT,
  35.     ASSERT_NOT])
  36.  
  37. def _compile(code, pattern, flags):
  38.     emit = code.append
  39.     _len = len
  40.     LITERAL_CODES = _LITERAL_CODES
  41.     REPEATING_CODES = _REPEATING_CODES
  42.     SUCCESS_CODES = _SUCCESS_CODES
  43.     ASSERT_CODES = _ASSERT_CODES
  44.     for op, av in pattern:
  45.         if op in LITERAL_CODES:
  46.             if flags & SRE_FLAG_IGNORECASE:
  47.                 emit(OPCODES[OP_IGNORE[op]])
  48.                 emit(_sre.getlower(av, flags))
  49.             else:
  50.                 emit(OPCODES[op])
  51.                 emit(av)
  52.         flags & SRE_FLAG_IGNORECASE
  53.         None if op is IN else flags & SRE_FLAG_DOTALL
  54.         if op in REPEATING_CODES:
  55.             if flags & SRE_FLAG_TEMPLATE:
  56.                 raise error, 'internal: unsupported template operator'
  57.                 emit(OPCODES[REPEAT])
  58.                 skip = _len(code)
  59.                 emit(0)
  60.                 emit(av[0])
  61.                 emit(av[1])
  62.                 _compile(code, av[2], flags)
  63.                 emit(OPCODES[SUCCESS])
  64.                 code[skip] = _len(code) - skip
  65.             elif _simple(av) and op is not REPEAT:
  66.                 if op is MAX_REPEAT:
  67.                     emit(OPCODES[REPEAT_ONE])
  68.                 else:
  69.                     emit(OPCODES[MIN_REPEAT_ONE])
  70.                 skip = _len(code)
  71.                 emit(0)
  72.                 emit(av[0])
  73.                 emit(av[1])
  74.                 _compile(code, av[2], flags)
  75.                 emit(OPCODES[SUCCESS])
  76.                 code[skip] = _len(code) - skip
  77.             else:
  78.                 emit(OPCODES[REPEAT])
  79.                 skip = _len(code)
  80.                 emit(0)
  81.                 emit(av[0])
  82.                 emit(av[1])
  83.                 _compile(code, av[2], flags)
  84.                 code[skip] = _len(code) - skip
  85.                 if op is MAX_REPEAT:
  86.                     emit(OPCODES[MAX_UNTIL])
  87.                 else:
  88.                     emit(OPCODES[MIN_UNTIL])
  89.         op is MAX_REPEAT
  90.         if op is SUBPATTERN:
  91.             if av[0]:
  92.                 emit(OPCODES[MARK])
  93.                 emit((av[0] - 1) * 2)
  94.             
  95.             _compile(code, av[1], flags)
  96.             if av[0]:
  97.                 emit(OPCODES[MARK])
  98.                 emit((av[0] - 1) * 2 + 1)
  99.             
  100.         av[0]
  101.         if op in SUCCESS_CODES:
  102.             emit(OPCODES[op])
  103.             continue
  104.         if op in ASSERT_CODES:
  105.             emit(OPCODES[op])
  106.             skip = _len(code)
  107.             emit(0)
  108.             if av[0] >= 0:
  109.                 emit(0)
  110.             else:
  111.                 (lo, hi) = av[1].getwidth()
  112.                 if lo != hi:
  113.                     raise error, 'look-behind requires fixed-width pattern'
  114.                 
  115.                 emit(lo)
  116.             _compile(code, av[1], flags)
  117.             emit(OPCODES[SUCCESS])
  118.             code[skip] = _len(code) - skip
  119.             continue
  120.         if op is CALL:
  121.             emit(OPCODES[op])
  122.             skip = _len(code)
  123.             emit(0)
  124.             _compile(code, av, flags)
  125.             emit(OPCODES[SUCCESS])
  126.             code[skip] = _len(code) - skip
  127.             continue
  128.         if op is AT:
  129.             emit(OPCODES[op])
  130.             if flags & SRE_FLAG_MULTILINE:
  131.                 av = AT_MULTILINE.get(av, av)
  132.             
  133.             if flags & SRE_FLAG_LOCALE:
  134.                 av = AT_LOCALE.get(av, av)
  135.             elif flags & SRE_FLAG_UNICODE:
  136.                 av = AT_UNICODE.get(av, av)
  137.             
  138.             emit(ATCODES[av])
  139.             continue
  140.         if op is BRANCH:
  141.             emit(OPCODES[op])
  142.             tail = []
  143.             tailappend = tail.append
  144.             for av in av[1]:
  145.                 skip = _len(code)
  146.                 emit(0)
  147.                 _compile(code, av, flags)
  148.                 emit(OPCODES[JUMP])
  149.                 tailappend(_len(code))
  150.                 emit(0)
  151.                 code[skip] = _len(code) - skip
  152.             
  153.             emit(0)
  154.             for tail in tail:
  155.                 code[tail] = _len(code) - tail
  156.             
  157.         if op is CATEGORY:
  158.             emit(OPCODES[op])
  159.             if flags & SRE_FLAG_LOCALE:
  160.                 av = CH_LOCALE[av]
  161.             elif flags & SRE_FLAG_UNICODE:
  162.                 av = CH_UNICODE[av]
  163.             
  164.             emit(CHCODES[av])
  165.             continue
  166.         None if op is GROUPREF else av[2]
  167.         raise ValueError, ('unsupported operand type', op)
  168.     
  169.  
  170.  
  171. def _compile_charset(charset, flags, code, fixup = None):
  172.     emit = code.append
  173.     if fixup is None:
  174.         fixup = _identityfunction
  175.     
  176.     for op, av in _optimize_charset(charset, fixup):
  177.         emit(OPCODES[op])
  178.         if op is NEGATE:
  179.             continue
  180.         if op is LITERAL:
  181.             emit(fixup(av))
  182.             continue
  183.         if op is RANGE:
  184.             emit(fixup(av[0]))
  185.             emit(fixup(av[1]))
  186.             continue
  187.         if op is CHARSET:
  188.             code.extend(av)
  189.             continue
  190.         None if op is BIGCHARSET else flags & SRE_FLAG_LOCALE
  191.         raise error, 'internal: unsupported set operator'
  192.     
  193.     emit(OPCODES[FAILURE])
  194.  
  195.  
  196. def _optimize_charset(charset, fixup):
  197.     out = []
  198.     outappend = out.append
  199.     charmap = [
  200.         0] * 256
  201.     
  202.     try:
  203.         for op, av in charset:
  204.             if op is NEGATE:
  205.                 outappend((op, av))
  206.                 continue
  207.             if op is LITERAL:
  208.                 charmap[fixup(av)] = 1
  209.                 continue
  210.             if op is RANGE:
  211.                 for i in range(fixup(av[0]), fixup(av[1]) + 1):
  212.                     charmap[i] = 1
  213.                 
  214.             if op is CATEGORY:
  215.                 return charset
  216.                 continue
  217.     except IndexError:
  218.         return _optimize_unicode(charset, fixup)
  219.  
  220.     i = p = n = 0
  221.     runs = []
  222.     runsappend = runs.append
  223.     for c in charmap:
  224.         if c:
  225.             if n == 0:
  226.                 p = i
  227.             
  228.             n = n + 1
  229.         elif n:
  230.             runsappend((p, n))
  231.             n = 0
  232.         
  233.         i = i + 1
  234.     
  235.     if n:
  236.         runsappend((p, n))
  237.     
  238.     if len(runs) <= 2:
  239.         for p, n in runs:
  240.             if n == 1:
  241.                 outappend((LITERAL, p))
  242.                 continue
  243.             outappend((RANGE, (p, p + n - 1)))
  244.         
  245.         if len(out) < len(charset):
  246.             return out
  247.         
  248.     else:
  249.         data = _mk_bitmap(charmap)
  250.         outappend((CHARSET, data))
  251.         return out
  252.     return charset
  253.  
  254.  
  255. def _mk_bitmap(bits):
  256.     data = []
  257.     dataappend = data.append
  258.     if _sre.CODESIZE == 2:
  259.         start = (1, 0)
  260.     else:
  261.         start = (0x1L, 0x0L)
  262.     (m, v) = start
  263.     for c in bits:
  264.         if c:
  265.             v = v + m
  266.         
  267.         m = m + m
  268.         if m > MAXCODE:
  269.             dataappend(v)
  270.             (m, v) = start
  271.             continue
  272.     
  273.     return data
  274.  
  275.  
  276. def _optimize_unicode(charset, fixup):
  277.     
  278.     try:
  279.         import array as array
  280.     except ImportError:
  281.         return charset
  282.  
  283.     charmap = [
  284.         0] * 65536
  285.     negate = 0
  286.     
  287.     try:
  288.         for op, av in charset:
  289.             if op is NEGATE:
  290.                 negate = 1
  291.                 continue
  292.             if op is LITERAL:
  293.                 charmap[fixup(av)] = 1
  294.                 continue
  295.             if op is RANGE:
  296.                 for i in xrange(fixup(av[0]), fixup(av[1]) + 1):
  297.                     charmap[i] = 1
  298.                 
  299.             if op is CATEGORY:
  300.                 return charset
  301.                 continue
  302.     except IndexError:
  303.         return charset
  304.  
  305.     if negate:
  306.         if sys.maxunicode != 65535:
  307.             return charset
  308.         
  309.         for i in xrange(65536):
  310.             charmap[i] = not charmap[i]
  311.         
  312.     
  313.     comps = { }
  314.     mapping = [
  315.         0] * 256
  316.     block = 0
  317.     data = []
  318.     for i in xrange(256):
  319.         chunk = tuple(charmap[i * 256:(i + 1) * 256])
  320.         new = comps.setdefault(chunk, block)
  321.         mapping[i] = new
  322.         if new == block:
  323.             block = block + 1
  324.             data = data + _mk_bitmap(chunk)
  325.             continue
  326.     
  327.     header = [
  328.         block]
  329.     if _sre.CODESIZE == 2:
  330.         code = 'H'
  331.     else:
  332.         code = 'I'
  333.     mapping = array.array('b', mapping).tostring()
  334.     mapping = array.array(code, mapping)
  335.     header = header + mapping.tolist()
  336.     data[0:0] = header
  337.     return [
  338.         (BIGCHARSET, data)]
  339.  
  340.  
  341. def _simple(av):
  342.     (lo, hi) = av[2].getwidth()
  343.     if lo == 0 and hi == MAXREPEAT:
  344.         raise error, 'nothing to repeat'
  345.     
  346.     return None if hi == hi else av[2][0][0] != SUBPATTERN
  347.  
  348.  
  349. def _compile_info(code, pattern, flags):
  350.     (lo, hi) = pattern.getwidth()
  351.     if lo == 0:
  352.         return None
  353.     
  354.     prefix = []
  355.     prefixappend = prefix.append
  356.     prefix_skip = 0
  357.     charset = []
  358.     charsetappend = charset.append
  359.     if not flags & SRE_FLAG_IGNORECASE:
  360.         for op, av in pattern.data:
  361.             None if op is LITERAL else op is LITERAL
  362.             break
  363.         
  364.         if not prefix and pattern.data:
  365.             (op, av) = pattern.data[0]
  366.             if op is SUBPATTERN and av[1]:
  367.                 (op, av) = av[1][0]
  368.                 if op is LITERAL:
  369.                     charsetappend((op, av))
  370.                 elif op is BRANCH:
  371.                     c = []
  372.                     cappend = c.append
  373.                     for p in av[1]:
  374.                         if not p:
  375.                             break
  376.                         
  377.                         (op, av) = p[0]
  378.                         if op is LITERAL:
  379.                             cappend((op, av))
  380.                             continue
  381.                         break
  382.                     else:
  383.                         charset = c
  384.                 
  385.             elif op is BRANCH:
  386.                 c = []
  387.                 cappend = c.append
  388.                 for p in av[1]:
  389.                     if not p:
  390.                         break
  391.                     
  392.                     (op, av) = p[0]
  393.                     if op is LITERAL:
  394.                         cappend((op, av))
  395.                         continue
  396.                     break
  397.                 else:
  398.                     charset = c
  399.             elif op is IN:
  400.                 charset = av
  401.             
  402.         
  403.     
  404.     emit = code.append
  405.     emit(OPCODES[INFO])
  406.     skip = len(code)
  407.     emit(0)
  408.     mask = 0
  409.     if prefix:
  410.         mask = SRE_INFO_PREFIX
  411.         if prefix_skip == prefix_skip:
  412.             pass
  413.         elif prefix_skip == len(pattern.data):
  414.             mask = mask + SRE_INFO_LITERAL
  415.         
  416.     elif charset:
  417.         mask = mask + SRE_INFO_CHARSET
  418.     
  419.     emit(mask)
  420.     if lo < MAXCODE:
  421.         emit(lo)
  422.     else:
  423.         emit(MAXCODE)
  424.         prefix = prefix[:MAXCODE]
  425.     if hi < MAXCODE:
  426.         emit(hi)
  427.     else:
  428.         emit(0)
  429.     if prefix:
  430.         emit(len(prefix))
  431.         emit(prefix_skip)
  432.         code.extend(prefix)
  433.         table = [
  434.             -1] + [
  435.             0] * len(prefix)
  436.         for i in xrange(len(prefix)):
  437.             table[i + 1] = table[i] + 1
  438.             while table[i + 1] > 0 and prefix[i] != prefix[table[i + 1] - 1]:
  439.                 table[i + 1] = table[table[i + 1] - 1] + 1
  440.         
  441.         code.extend(table[1:])
  442.     elif charset:
  443.         _compile_charset(charset, flags, code)
  444.     
  445.     code[skip] = len(code) - skip
  446.  
  447.  
  448. try:
  449.     unicode
  450. except NameError:
  451.     STRING_TYPES = (type(''),)
  452.  
  453. STRING_TYPES = (type(''), type(unicode('')))
  454.  
  455. def isstring(obj):
  456.     for tp in STRING_TYPES:
  457.         if isinstance(obj, tp):
  458.             return 1
  459.             continue
  460.     
  461.     return 0
  462.  
  463.  
  464. def _code(p, flags):
  465.     flags = p.pattern.flags | flags
  466.     code = []
  467.     _compile_info(code, p, flags)
  468.     _compile(code, p.data, flags)
  469.     code.append(OPCODES[SUCCESS])
  470.     return code
  471.  
  472.  
  473. def compile(p, flags = 0):
  474.     if isstring(p):
  475.         import sre_parse as sre_parse
  476.         pattern = p
  477.         p = sre_parse.parse(p, flags)
  478.     else:
  479.         pattern = None
  480.     code = _code(p, flags)
  481.     if p.pattern.groups > 100:
  482.         raise AssertionError('sorry, but this version only supports 100 named groups')
  483.     
  484.     groupindex = p.pattern.groupdict
  485.     indexgroup = [
  486.         None] * p.pattern.groups
  487.     for k, i in groupindex.items():
  488.         indexgroup[i] = k
  489.     
  490.     return _sre.compile(pattern, flags | p.pattern.flags, code, p.pattern.groups - 1, groupindex, indexgroup)
  491.  
  492.